home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / programm / GNU_C++ / LIB / MAKE3761.LZH / info / make.info-7 < prev    next >
Encoding:
GNU Info File  |  1998-07-20  |  46.6 KB  |  1,181 lines
  1. This is Info file make.info, produced by Makeinfo version 1.67 from the
  2. input file make.texinfo.
  3.  
  4. INFO-DIR-SECTION The GNU make utility
  5. START-INFO-DIR-ENTRY
  6. * GNU make: (make.info).           The GNU make utility.
  7. END-INFO-DIR-ENTRY
  8.  
  9.    This file documents the GNU Make utility, which determines
  10. automatically which pieces of a large program need to be recompiled,
  11. and issues the commands to recompile them.
  12.  
  13.    This is Edition 0.51, last updated 26 Aug 1997, of `The GNU Make
  14. Manual', for `make', Version 3.76 Beta.
  15.  
  16.    Copyright (C) 1988, '89, '90, '91, '92, '93, '94, '95, '96, '97     Free
  17. Software Foundation, Inc.
  18.  
  19.    Permission is granted to make and distribute verbatim copies of this
  20. manual provided the copyright notice and this permission notice are
  21. preserved on all copies.
  22.  
  23.    Permission is granted to copy and distribute modified versions of
  24. this manual under the conditions for verbatim copying, provided that
  25. the entire resulting derived work is distributed under the terms of a
  26. permission notice identical to this one.
  27.  
  28.    Permission is granted to copy and distribute translations of this
  29. manual into another language, under the above conditions for modified
  30. versions, except that this permission notice may be stated in a
  31. translation approved by the Free Software Foundation.
  32.  
  34. File: make.info,  Node: Command Variables,  Next: Directory Variables,  Prev: Utilities in Makefiles,  Up: Makefile Conventions
  35.  
  36. Variables for Specifying Commands
  37. =================================
  38.  
  39.    Makefiles should provide variables for overriding certain commands,
  40. options, and so on.
  41.  
  42.    In particular, you should run most utility programs via variables.
  43. Thus, if you use Bison, have a variable named `BISON' whose default
  44. value is set with `BISON = bison', and refer to it with `$(BISON)'
  45. whenever you need to use Bison.
  46.  
  47.    File management utilities such as `ln', `rm', `mv', and so on, need
  48. not be referred to through variables in this way, since users don't
  49. need to replace them with other programs.
  50.  
  51.    Each program-name variable should come with an options variable that
  52. is used to supply options to the program.  Append `FLAGS' to the
  53. program-name variable name to get the options variable name--for
  54. example, `BISONFLAGS'.  (The name `CFLAGS' is an exception to this
  55. rule, but we keep it because it is standard.)  Use `CPPFLAGS' in any
  56. compilation command that runs the preprocessor, and use `LDFLAGS' in
  57. any compilation command that does linking as well as in any direct use
  58. of `ld'.
  59.  
  60.    If there are C compiler options that *must* be used for proper
  61. compilation of certain files, do not include them in `CFLAGS'.  Users
  62. expect to be able to specify `CFLAGS' freely themselves.  Instead,
  63. arrange to pass the necessary options to the C compiler independently
  64. of `CFLAGS', by writing them explicitly in the compilation commands or
  65. by defining an implicit rule, like this:
  66.  
  67.      CFLAGS = -g
  68.      ALL_CFLAGS = -I. $(CFLAGS)
  69.      .c.o:
  70.              $(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) $<
  71.  
  72.    Do include the `-g' option in `CFLAGS', because that is not
  73. *required* for proper compilation.  You can consider it a default that
  74. is only recommended.  If the package is set up so that it is compiled
  75. with GCC by default, then you might as well include `-O' in the default
  76. value of `CFLAGS' as well.
  77.  
  78.    Put `CFLAGS' last in the compilation command, after other variables
  79. containing compiler options, so the user can use `CFLAGS' to override
  80. the others.
  81.  
  82.    `CFLAGS' should be used in every invocation of the C compiler, both
  83. those which do compilation and those which do linking.
  84.  
  85.    Every Makefile should define the variable `INSTALL', which is the
  86. basic command for installing a file into the system.
  87.  
  88.    Every Makefile should also define the variables `INSTALL_PROGRAM'
  89. and `INSTALL_DATA'.  (The default for each of these should be
  90. `$(INSTALL)'.)  Then it should use those variables as the commands for
  91. actual installation, for executables and nonexecutables respectively.
  92. Use these variables as follows:
  93.  
  94.      $(INSTALL_PROGRAM) foo $(bindir)/foo
  95.      $(INSTALL_DATA) libfoo.a $(libdir)/libfoo.a
  96.  
  97. Always use a file name, not a directory name, as the second argument of
  98. the installation commands.  Use a separate command for each file to be
  99. installed.
  100.  
  102. File: make.info,  Node: Directory Variables,  Next: Standard Targets,  Prev: Command Variables,  Up: Makefile Conventions
  103.  
  104. Variables for Installation Directories
  105. ======================================
  106.  
  107.    Installation directories should always be named by variables, so it
  108. is easy to install in a nonstandard place.  The standard names for these
  109. variables are described below.  They are based on a standard filesystem
  110. layout; variants of it are used in SVR4, 4.4BSD, Linux, Ultrix v4, and
  111. other modern operating systems.
  112.  
  113.    These two variables set the root for the installation.  All the other
  114. installation directories should be subdirectories of one of these two,
  115. and nothing should be directly installed into these two directories.
  116.  
  117. `prefix'
  118.      A prefix used in constructing the default values of the variables
  119.      listed below.  The default value of `prefix' should be
  120.      `/usr/local'.  When building the complete GNU system, the prefix
  121.      will be empty and `/usr' will be a symbolic link to `/'.  (If you
  122.      are using Autoconf, write it as `@prefix@'.)
  123.  
  124. `exec_prefix'
  125.      A prefix used in constructing the default values of some of the
  126.      variables listed below.  The default value of `exec_prefix' should
  127.      be `$(prefix)'.  (If you are using Autoconf, write it as
  128.      `@exec_prefix@'.)
  129.  
  130.      Generally, `$(exec_prefix)' is used for directories that contain
  131.      machine-specific files (such as executables and subroutine
  132.      libraries), while `$(prefix)' is used directly for other
  133.      directories.
  134.  
  135.    Executable programs are installed in one of the following
  136. directories.
  137.  
  138. `bindir'
  139.      The directory for installing executable programs that users can
  140.      run.  This should normally be `/usr/local/bin', but write it as
  141.      `$(exec_prefix)/bin'.  (If you are using Autoconf, write it as
  142.      `@bindir@'.)
  143.  
  144. `sbindir'
  145.      The directory for installing executable programs that can be run
  146.      from the shell, but are only generally useful to system
  147.      administrators.  This should normally be `/usr/local/sbin', but
  148.      write it as `$(exec_prefix)/sbin'.  (If you are using Autoconf,
  149.      write it as `@sbindir@'.)
  150.  
  151. `libexecdir'
  152.      The directory for installing executable programs to be run by other
  153.      programs rather than by users.  This directory should normally be
  154.      `/usr/local/libexec', but write it as `$(exec_prefix)/libexec'.
  155.      (If you are using Autoconf, write it as `@libexecdir@'.)
  156.  
  157.    Data files used by the program during its execution are divided into
  158. categories in two ways.
  159.  
  160.    * Some files are normally modified by programs; others are never
  161.      normally modified (though users may edit some of these).
  162.  
  163.    * Some files are architecture-independent and can be shared by all
  164.      machines at a site; some are architecture-dependent and can be
  165.      shared only by machines of the same kind and operating system;
  166.      others may never be shared between two machines.
  167.  
  168.    This makes for six different possibilities.  However, we want to
  169. discourage the use of architecture-dependent files, aside from object
  170. files and libraries.  It is much cleaner to make other data files
  171. architecture-independent, and it is generally not hard.
  172.  
  173.    Therefore, here are the variables Makefiles should use to specify
  174. directories:
  175.  
  176. `datadir'
  177.      The directory for installing read-only architecture independent
  178.      data files.  This should normally be `/usr/local/share', but write
  179.      it as `$(prefix)/share'.  (If you are using Autoconf, write it as
  180.      `@datadir@'.) As a special exception, see `$(infodir)' and
  181.      `$(includedir)' below.
  182.  
  183. `sysconfdir'
  184.      The directory for installing read-only data files that pertain to a
  185.      single machine-that is to say, files for configuring a host.
  186.      Mailer and network configuration files, `/etc/passwd', and so
  187.      forth belong here.  All the files in this directory should be
  188.      ordinary ASCII text files.  This directory should normally be
  189.      `/usr/local/etc', but write it as `$(prefix)/etc'.  (If you are
  190.      using Autoconf, write it as `@sysconfdir@'.)
  191.  
  192.      Do not install executables here in this directory (they probably
  193.      belong in `$(libexecdir)' or `$(sbindir)').  Also do not install
  194.      files that are modified in the normal course of their use (programs
  195.      whose purpose is to change the configuration of the system
  196.      excluded).  Those probably belong in `$(localstatedir)'.
  197.  
  198. `sharedstatedir'
  199.      The directory for installing architecture-independent data files
  200.      which the programs modify while they run.  This should normally be
  201.      `/usr/local/com', but write it as `$(prefix)/com'.  (If you are
  202.      using Autoconf, write it as `@sharedstatedir@'.)
  203.  
  204. `localstatedir'
  205.      The directory for installing data files which the programs modify
  206.      while they run, and that pertain to one specific machine.  Users
  207.      should never need to modify files in this directory to configure
  208.      the package's operation; put such configuration information in
  209.      separate files that go in `$(datadir)' or `$(sysconfdir)'.
  210.      `$(localstatedir)' should normally be `/usr/local/var', but write
  211.      it as `$(prefix)/var'.  (If you are using Autoconf, write it as
  212.      `@localstatedir@'.)
  213.  
  214. `libdir'
  215.      The directory for object files and libraries of object code.  Do
  216.      not install executables here, they probably ought to go in
  217.      `$(libexecdir)' instead.  The value of `libdir' should normally be
  218.      `/usr/local/lib', but write it as `$(exec_prefix)/lib'.  (If you
  219.      are using Autoconf, write it as `@libdir@'.)
  220.  
  221. `infodir'
  222.      The directory for installing the Info files for this package.  By
  223.      default, it should be `/usr/local/info', but it should be written
  224.      as `$(prefix)/info'.  (If you are using Autoconf, write it as
  225.      `@infodir@'.)
  226.  
  227. `lispdir'
  228.      The directory for installing any Emacs Lisp files in this package.
  229.      By default, it should be `/usr/local/share/emacs/site-lisp', but
  230.      it should be written as `$(prefix)/share/emacs/site-lisp'.
  231.  
  232.      If you are using Autoconf, write the default as `@lispdir@'.  In
  233.      order to make `@lispdir@' work, you need the following lines in
  234.      your `configure.in' file:
  235.  
  236.           lispdir='${datadir}/emacs/site-lisp'
  237.           AC_SUBST(lispdir)
  238.  
  239. `includedir'
  240.      The directory for installing header files to be included by user
  241.      programs with the C `#include' preprocessor directive.  This
  242.      should normally be `/usr/local/include', but write it as
  243.      `$(prefix)/include'.  (If you are using Autoconf, write it as
  244.      `@includedir@'.)
  245.  
  246.      Most compilers other than GCC do not look for header files in
  247.      directory `/usr/local/include'.  So installing the header files
  248.      this way is only useful with GCC.  Sometimes this is not a problem
  249.      because some libraries are only really intended to work with GCC.
  250.      But some libraries are intended to work with other compilers.
  251.      They should install their header files in two places, one
  252.      specified by `includedir' and one specified by `oldincludedir'.
  253.  
  254. `oldincludedir'
  255.      The directory for installing `#include' header files for use with
  256.      compilers other than GCC.  This should normally be `/usr/include'.
  257.      (If you are using Autoconf, you can write it as `@oldincludedir@'.)
  258.  
  259.      The Makefile commands should check whether the value of
  260.      `oldincludedir' is empty.  If it is, they should not try to use
  261.      it; they should cancel the second installation of the header files.
  262.  
  263.      A package should not replace an existing header in this directory
  264.      unless the header came from the same package.  Thus, if your Foo
  265.      package provides a header file `foo.h', then it should install the
  266.      header file in the `oldincludedir' directory if either (1) there
  267.      is no `foo.h' there or (2) the `foo.h' that exists came from the
  268.      Foo package.
  269.  
  270.      To tell whether `foo.h' came from the Foo package, put a magic
  271.      string in the file--part of a comment--and `grep' for that string.
  272.  
  273.    Unix-style man pages are installed in one of the following:
  274.  
  275. `mandir'
  276.      The top-level directory for installing the man pages (if any) for
  277.      this package.  It will normally be `/usr/local/man', but you should
  278.      write it as `$(prefix)/man'.  (If you are using Autoconf, write it
  279.      as `@mandir@'.)
  280.  
  281. `man1dir'
  282.      The directory for installing section 1 man pages.  Write it as
  283.      `$(mandir)/man1'.
  284.  
  285. `man2dir'
  286.      The directory for installing section 2 man pages.  Write it as
  287.      `$(mandir)/man2'
  288.  
  289. `...'
  290.      *Don't make the primary documentation for any GNU software be a
  291.      man page.  Write a manual in Texinfo instead.  Man pages are just
  292.      for the sake of people running GNU software on Unix, which is a
  293.      secondary application only.*
  294.  
  295. `manext'
  296.      The file name extension for the installed man page.  This should
  297.      contain a period followed by the appropriate digit; it should
  298.      normally be `.1'.
  299.  
  300. `man1ext'
  301.      The file name extension for installed section 1 man pages.
  302.  
  303. `man2ext'
  304.      The file name extension for installed section 2 man pages.
  305.  
  306. `...'
  307.      Use these names instead of `manext' if the package needs to
  308.      install man pages in more than one section of the manual.
  309.  
  310.    And finally, you should set the following variable:
  311.  
  312. `srcdir'
  313.      The directory for the sources being compiled.  The value of this
  314.      variable is normally inserted by the `configure' shell script.
  315.      (If you are using Autconf, use `srcdir = @srcdir@'.)
  316.  
  317.    For example:
  318.  
  319.      # Common prefix for installation directories.
  320.      # NOTE: This directory must exist when you start the install.
  321.      prefix = /usr/local
  322.      exec_prefix = $(prefix)
  323.      # Where to put the executable for the command `gcc'.
  324.      bindir = $(exec_prefix)/bin
  325.      # Where to put the directories used by the compiler.
  326.      libexecdir = $(exec_prefix)/libexec
  327.      # Where to put the Info files.
  328.      infodir = $(prefix)/info
  329.  
  330.    If your program installs a large number of files into one of the
  331. standard user-specified directories, it might be useful to group them
  332. into a subdirectory particular to that program.  If you do this, you
  333. should write the `install' rule to create these subdirectories.
  334.  
  335.    Do not expect the user to include the subdirectory name in the value
  336. of any of the variables listed above.  The idea of having a uniform set
  337. of variable names for installation directories is to enable the user to
  338. specify the exact same values for several different GNU packages.  In
  339. order for this to be useful, all the packages must be designed so that
  340. they will work sensibly when the user does so.
  341.  
  343. File: make.info,  Node: Standard Targets,  Next: Install Command Categories,  Prev: Directory Variables,  Up: Makefile Conventions
  344.  
  345. Standard Targets for Users
  346. ==========================
  347.  
  348.    All GNU programs should have the following targets in their
  349. Makefiles:
  350.  
  351. `all'
  352.      Compile the entire program.  This should be the default target.
  353.      This target need not rebuild any documentation files; Info files
  354.      should normally be included in the distribution, and DVI files
  355.      should be made only when explicitly asked for.
  356.  
  357.      By default, the Make rules should compile and link with `-g', so
  358.      that executable programs have debugging symbols.  Users who don't
  359.      mind being helpless can strip the executables later if they wish.
  360.  
  361. `install'
  362.      Compile the program and copy the executables, libraries, and so on
  363.      to the file names where they should reside for actual use.  If
  364.      there is a simple test to verify that a program is properly
  365.      installed, this target should run that test.
  366.  
  367.      Do not strip executables when installing them.  Devil-may-care
  368.      users can use the `install-strip' target to do that.
  369.  
  370.      If possible, write the `install' target rule so that it does not
  371.      modify anything in the directory where the program was built,
  372.      provided `make all' has just been done.  This is convenient for
  373.      building the program under one user name and installing it under
  374.      another.
  375.  
  376.      The commands should create all the directories in which files are
  377.      to be installed, if they don't already exist.  This includes the
  378.      directories specified as the values of the variables `prefix' and
  379.      `exec_prefix', as well as all subdirectories that are needed.  One
  380.      way to do this is by means of an `installdirs' target as described
  381.      below.
  382.  
  383.      Use `-' before any command for installing a man page, so that
  384.      `make' will ignore any errors.  This is in case there are systems
  385.      that don't have the Unix man page documentation system installed.
  386.  
  387.      The way to install Info files is to copy them into `$(infodir)'
  388.      with `$(INSTALL_DATA)' (*note Command Variables::.), and then run
  389.      the `install-info' program if it is present.  `install-info' is a
  390.      program that edits the Info `dir' file to add or update the menu
  391.      entry for the given Info file; it is part of the Texinfo package.
  392.      Here is a sample rule to install an Info file:
  393.  
  394.           $(infodir)/foo.info: foo.info
  395.                   $(POST_INSTALL)
  396.           # There may be a newer info file in . than in srcdir.
  397.                   -if test -f foo.info; then d=.; \
  398.                    else d=$(srcdir); fi; \
  399.                   $(INSTALL_DATA) $$d/foo.info $@; \
  400.           # Run install-info only if it exists.
  401.           # Use `if' instead of just prepending `-' to the
  402.           # line so we notice real errors from install-info.
  403.           # We use `$(SHELL) -c' because some shells do not
  404.           # fail gracefully when there is an unknown command.
  405.                   if $(SHELL) -c 'install-info --version' \
  406.                      >/dev/null 2>&1; then \
  407.                     install-info --dir-file=$(infodir)/dir \
  408.                                  $(infodir)/foo.info; \
  409.                   else true; fi
  410.  
  411.      When writing the `install' target, you must classify all the
  412.      commands into three categories: normal ones, "pre-installation"
  413.      commands and "post-installation" commands.  *Note Install Command
  414.      Categories::.
  415.  
  416. `uninstall'
  417.      Delete all the installed files--the copies that the `install'
  418.      target creates.
  419.  
  420.      This rule should not modify the directories where compilation is
  421.      done, only the directories where files are installed.
  422.  
  423.      The uninstallation commands are divided into three categories,
  424.      just like the installation commands.  *Note Install Command
  425.      Categories::.
  426.  
  427. `install-strip'
  428.      Like `install', but strip the executable files while installing
  429.      them.  In many cases, the definition of this target can be very
  430.      simple:
  431.  
  432.           install-strip:
  433.                   $(MAKE) INSTALL_PROGRAM='$(INSTALL_PROGRAM) -s' \
  434.                           install
  435.  
  436.      Normally we do not recommend stripping an executable unless you
  437.      are sure the program has no bugs.  However, it can be reasonable
  438.      to install a stripped executable for actual execution while saving
  439.      the unstripped executable elsewhere in case there is a bug.
  440.  
  441. `clean'
  442.      Delete all files from the current directory that are normally
  443.      created by building the program.  Don't delete the files that
  444.      record the configuration.  Also preserve files that could be made
  445.      by building, but normally aren't because the distribution comes
  446.      with them.
  447.  
  448.      Delete `.dvi' files here if they are not part of the distribution.
  449.  
  450. `distclean'
  451.      Delete all files from the current directory that are created by
  452.      configuring or building the program.  If you have unpacked the
  453.      source and built the program without creating any other files,
  454.      `make distclean' should leave only the files that were in the
  455.      distribution.
  456.  
  457. `mostlyclean'
  458.      Like `clean', but may refrain from deleting a few files that people
  459.      normally don't want to recompile.  For example, the `mostlyclean'
  460.      target for GCC does not delete `libgcc.a', because recompiling it
  461.      is rarely necessary and takes a lot of time.
  462.  
  463. `maintainer-clean'
  464.      Delete almost everything from the current directory that can be
  465.      reconstructed with this Makefile.  This typically includes
  466.      everything deleted by `distclean', plus more: C source files
  467.      produced by Bison, tags tables, Info files, and so on.
  468.  
  469.      The reason we say "almost everything" is that running the command
  470.      `make maintainer-clean' should not delete `configure' even if
  471.      `configure' can be remade using a rule in the Makefile.  More
  472.      generally, `make maintainer-clean' should not delete anything that
  473.      needs to exist in order to run `configure' and then begin to build
  474.      the program.  This is the only exception; `maintainer-clean' should
  475.      delete everything else that can be rebuilt.
  476.  
  477.      The `maintainer-clean' target is intended to be used by a
  478.      maintainer of the package, not by ordinary users.  You may need
  479.      special tools to reconstruct some of the files that `make
  480.      maintainer-clean' deletes.  Since these files are normally
  481.      included in the distribution, we don't take care to make them easy
  482.      to reconstruct.  If you find you need to unpack the full
  483.      distribution again, don't blame us.
  484.  
  485.      To help make users aware of this, the commands for the special
  486.      `maintainer-clean' target should start with these two:
  487.  
  488.           @echo 'This command is intended for maintainers to use; it'
  489.           @echo 'deletes files that may need special tools to rebuild.'
  490.  
  491. `TAGS'
  492.      Update a tags table for this program.
  493.  
  494. `info'
  495.      Generate any Info files needed.  The best way to write the rules
  496.      is as follows:
  497.  
  498.           info: foo.info
  499.           
  500.           foo.info: foo.texi chap1.texi chap2.texi
  501.                   $(MAKEINFO) $(srcdir)/foo.texi
  502.  
  503.      You must define the variable `MAKEINFO' in the Makefile.  It should
  504.      run the `makeinfo' program, which is part of the Texinfo
  505.      distribution.
  506.  
  507.      Normally a GNU distribution comes with Info files, and that means
  508.      the Info files are present in the source directory.  Therefore,
  509.      the Make rule for an info file should update it in the source
  510.      directory.  When users build the package, ordinarily Make will not
  511.      update the Info files because they will already be up to date.
  512.  
  513. `dvi'
  514.      Generate DVI files for all Texinfo documentation.  For example:
  515.  
  516.           dvi: foo.dvi
  517.           
  518.           foo.dvi: foo.texi chap1.texi chap2.texi
  519.                   $(TEXI2DVI) $(srcdir)/foo.texi
  520.  
  521.      You must define the variable `TEXI2DVI' in the Makefile.  It should
  522.      run the program `texi2dvi', which is part of the Texinfo
  523.      distribution.(1)  Alternatively, write just the dependencies, and
  524.      allow GNU `make' to provide the command.
  525.  
  526. `dist'
  527.      Create a distribution tar file for this program.  The tar file
  528.      should be set up so that the file names in the tar file start with
  529.      a subdirectory name which is the name of the package it is a
  530.      distribution for.  This name can include the version number.
  531.  
  532.      For example, the distribution tar file of GCC version 1.40 unpacks
  533.      into a subdirectory named `gcc-1.40'.
  534.  
  535.      The easiest way to do this is to create a subdirectory
  536.      appropriately named, use `ln' or `cp' to install the proper files
  537.      in it, and then `tar' that subdirectory.
  538.  
  539.      Compress the tar file file with `gzip'.  For example, the actual
  540.      distribution file for GCC version 1.40 is called `gcc-1.40.tar.gz'.
  541.  
  542.      The `dist' target should explicitly depend on all non-source files
  543.      that are in the distribution, to make sure they are up to date in
  544.      the distribution.  *Note Making Releases: (standards)Releases.
  545.  
  546. `check'
  547.      Perform self-tests (if any).  The user must build the program
  548.      before running the tests, but need not install the program; you
  549.      should write the self-tests so that they work when the program is
  550.      built but not installed.
  551.  
  552.    The following targets are suggested as conventional names, for
  553. programs in which they are useful.
  554.  
  555. `installcheck'
  556.      Perform installation tests (if any).  The user must build and
  557.      install the program before running the tests.  You should not
  558.      assume that `$(bindir)' is in the search path.
  559.  
  560. `installdirs'
  561.      It's useful to add a target named `installdirs' to create the
  562.      directories where files are installed, and their parent
  563.      directories.  There is a script called `mkinstalldirs' which is
  564.      convenient for this; you can find it in the Texinfo package.  You
  565.      can use a rule like this:
  566.  
  567.           # Make sure all installation directories (e.g. $(bindir))
  568.           # actually exist by making them if necessary.
  569.           installdirs: mkinstalldirs
  570.                   $(srcdir)/mkinstalldirs $(bindir) $(datadir) \
  571.                                           $(libdir) $(infodir) \
  572.                                           $(mandir)
  573.  
  574.      This rule should not modify the directories where compilation is
  575.      done.  It should do nothing but create installation directories.
  576.  
  577.    ---------- Footnotes ----------
  578.  
  579.    (1)  `texi2dvi' uses TeX to do the real work of formatting. TeX is
  580. not distributed with Texinfo.
  581.  
  583. File: make.info,  Node: Install Command Categories,  Prev: Standard Targets,  Up: Makefile Conventions
  584.  
  585. Install Command Categories
  586. ==========================
  587.  
  588.    When writing the `install' target, you must classify all the
  589. commands into three categories: normal ones, "pre-installation"
  590. commands and "post-installation" commands.
  591.  
  592.    Normal commands move files into their proper places, and set their
  593. modes.  They may not alter any files except the ones that come entirely
  594. from the package they belong to.
  595.  
  596.    Pre-installation and post-installation commands may alter other
  597. files; in particular, they can edit global configuration files or data
  598. bases.
  599.  
  600.    Pre-installation commands are typically executed before the normal
  601. commands, and post-installation commands are typically run after the
  602. normal commands.
  603.  
  604.    The most common use for a post-installation command is to run
  605. `install-info'.  This cannot be done with a normal command, since it
  606. alters a file (the Info directory) which does not come entirely and
  607. solely from the package being installed.  It is a post-installation
  608. command because it needs to be done after the normal command which
  609. installs the package's Info files.
  610.  
  611.    Most programs don't need any pre-installation commands, but we have
  612. the feature just in case it is needed.
  613.  
  614.    To classify the commands in the `install' rule into these three
  615. categories, insert "category lines" among them.  A category line
  616. specifies the category for the commands that follow.
  617.  
  618.    A category line consists of a tab and a reference to a special Make
  619. variable, plus an optional comment at the end.  There are three
  620. variables you can use, one for each category; the variable name
  621. specifies the category.  Category lines are no-ops in ordinary execution
  622. because these three Make variables are normally undefined (and you
  623. *should not* define them in the makefile).
  624.  
  625.    Here are the three possible category lines, each with a comment that
  626. explains what it means:
  627.  
  628.              $(PRE_INSTALL)     # Pre-install commands follow.
  629.              $(POST_INSTALL)    # Post-install commands follow.
  630.              $(NORMAL_INSTALL)  # Normal commands follow.
  631.  
  632.    If you don't use a category line at the beginning of the `install'
  633. rule, all the commands are classified as normal until the first category
  634. line.  If you don't use any category lines, all the commands are
  635. classified as normal.
  636.  
  637.    These are the category lines for `uninstall':
  638.  
  639.              $(PRE_UNINSTALL)     # Pre-uninstall commands follow.
  640.              $(POST_UNINSTALL)    # Post-uninstall commands follow.
  641.              $(NORMAL_UNINSTALL)  # Normal commands follow.
  642.  
  643.    Typically, a pre-uninstall command would be used for deleting entries
  644. from the Info directory.
  645.  
  646.    If the `install' or `uninstall' target has any dependencies which
  647. act as subroutines of installation, then you should start *each*
  648. dependency's commands with a category line, and start the main target's
  649. commands with a category line also.  This way, you can ensure that each
  650. command is placed in the right category regardless of which of the
  651. dependencies actually run.
  652.  
  653.    Pre-installation and post-installation commands should not run any
  654. programs except for these:
  655.  
  656.      [ basename bash cat chgrp chmod chown cmp cp dd diff echo
  657.      egrep expand expr false fgrep find getopt grep gunzip gzip
  658.      hostname install install-info kill ldconfig ln ls md5sum
  659.      mkdir mkfifo mknod mv printenv pwd rm rmdir sed sort tee
  660.      test touch true uname xargs yes
  661.  
  662.    The reason for distinguishing the commands in this way is for the
  663. sake of making binary packages.  Typically a binary package contains
  664. all the executables and other files that need to be installed, and has
  665. its own method of installing them--so it does not need to run the normal
  666. installation commands.  But installing the binary package does need to
  667. execute the pre-installation and post-installation commands.
  668.  
  669.    Programs to build binary packages work by extracting the
  670. pre-installation and post-installation commands.  Here is one way of
  671. extracting the pre-installation commands:
  672.  
  673.      make -n install -o all \
  674.            PRE_INSTALL=pre-install \
  675.            POST_INSTALL=post-install \
  676.            NORMAL_INSTALL=normal-install \
  677.        | gawk -f pre-install.awk
  678.  
  679. where the file `pre-install.awk' could contain this:
  680.  
  681.      $0 ~ /^\t[ \t]*(normal_install|post_install)[ \t]*$/ {on = 0}
  682.      on {print $0}
  683.      $0 ~ /^\t[ \t]*pre_install[ \t]*$/ {on = 1}
  684.  
  685.    The resulting file of pre-installation commands is executed as a
  686. shell script as part of installing the binary package.
  687.  
  689. File: make.info,  Node: Quick Reference,  Next: Complex Makefile,  Prev: Makefile Conventions,  Up: Top
  690.  
  691. Quick Reference
  692. ***************
  693.  
  694.    This appendix summarizes the directives, text manipulation functions,
  695. and special variables which GNU `make' understands.  *Note Special
  696. Targets::, *Note Catalogue of Implicit Rules: Catalogue of Rules, and
  697. *Note Summary of Options: Options Summary, for other summaries.
  698.  
  699.    Here is a summary of the directives GNU `make' recognizes:
  700.  
  701. `define VARIABLE'
  702. `endef'
  703.      Define a multi-line, recursively-expanded variable.
  704.      *Note Sequences::.
  705.  
  706. `ifdef VARIABLE'
  707. `ifndef VARIABLE'
  708. `ifeq (A,B)'
  709. `ifeq "A" "B"'
  710. `ifeq 'A' 'B''
  711. `ifneq (A,B)'
  712. `ifneq "A" "B"'
  713. `ifneq 'A' 'B''
  714. `else'
  715. `endif'
  716.      Conditionally evaluate part of the makefile.
  717.      *Note Conditionals::.
  718.  
  719. `include FILE'
  720.      Include another makefile.
  721.      *Note Including Other Makefiles: Include.
  722.  
  723. `override VARIABLE = VALUE'
  724. `override VARIABLE := VALUE'
  725. `override VARIABLE += VALUE'
  726. `override define VARIABLE'
  727. `endef'
  728.      Define a variable, overriding any previous definition, even one
  729.      from the command line.
  730.      *Note The `override' Directive: Override Directive.
  731.  
  732. `export'
  733.      Tell `make' to export all variables to child processes by default.
  734.      *Note Communicating Variables to a Sub-`make': Variables/Recursion.
  735.  
  736. `export VARIABLE'
  737. `export VARIABLE = VALUE'
  738. `export VARIABLE := VALUE'
  739. `export VARIABLE += VALUE'
  740. `unexport VARIABLE'
  741.      Tell `make' whether or not to export a particular variable to child
  742.      processes.
  743.      *Note Communicating Variables to a Sub-`make': Variables/Recursion.
  744.  
  745. `vpath PATTERN PATH'
  746.      Specify a search path for files matching a `%' pattern.
  747.      *Note The `vpath' Directive: Selective Search.
  748.  
  749. `vpath PATTERN'
  750.      Remove all search paths previously specified for PATTERN.
  751.  
  752. `vpath'
  753.      Remove all search paths previously specified in any `vpath'
  754.      directive.
  755.  
  756.    Here is a summary of the text manipulation functions (*note
  757. Functions::.):
  758.  
  759. `$(subst FROM,TO,TEXT)'
  760.      Replace FROM with TO in TEXT.
  761.      *Note Functions for String Substitution and Analysis: Text
  762.      Functions.
  763.  
  764. `$(patsubst PATTERN,REPLACEMENT,TEXT)'
  765.      Replace words matching PATTERN with REPLACEMENT in TEXT.
  766.      *Note Functions for String Substitution and Analysis: Text
  767.      Functions.
  768.  
  769. `$(strip STRING)'
  770.      Remove excess whitespace characters from STRING.
  771.      *Note Functions for String Substitution and Analysis: Text
  772.      Functions.
  773.  
  774. `$(findstring FIND,TEXT)'
  775.      Locate FIND in TEXT.
  776.      *Note Functions for String Substitution and Analysis: Text
  777.      Functions.
  778.  
  779. `$(filter PATTERN...,TEXT)'
  780.      Select words in TEXT that match one of the PATTERN words.
  781.      *Note Functions for String Substitution and Analysis: Text
  782.      Functions.
  783.  
  784. `$(filter-out PATTERN...,TEXT)'
  785.      Select words in TEXT that *do not* match any of the PATTERN words.
  786.      *Note Functions for String Substitution and Analysis: Text
  787.      Functions.
  788.  
  789. `$(sort LIST)'
  790.      Sort the words in LIST lexicographically, removing duplicates.
  791.      *Note Functions for String Substitution and Analysis: Text
  792.      Functions.
  793.  
  794. `$(dir NAMES...)'
  795.      Extract the directory part of each file name.
  796.      *Note Functions for File Names: File Name Functions.
  797.  
  798. `$(notdir NAMES...)'
  799.      Extract the non-directory part of each file name.
  800.      *Note Functions for File Names: File Name Functions.
  801.  
  802. `$(suffix NAMES...)'
  803.      Extract the suffix (the last `.' and following characters) of each
  804.      file name.
  805.      *Note Functions for File Names: File Name Functions.
  806.  
  807. `$(basename NAMES...)'
  808.      Extract the base name (name without suffix) of each file name.
  809.      *Note Functions for File Names: File Name Functions.
  810.  
  811. `$(addsuffix SUFFIX,NAMES...)'
  812.      Append SUFFIX to each word in NAMES.
  813.      *Note Functions for File Names: File Name Functions.
  814.  
  815. `$(addprefix PREFIX,NAMES...)'
  816.      Prepend PREFIX to each word in NAMES.
  817.      *Note Functions for File Names: File Name Functions.
  818.  
  819. `$(join LIST1,LIST2)'
  820.      Join two parallel lists of words.
  821.      *Note Functions for File Names: File Name Functions.
  822.  
  823. `$(word N,TEXT)'
  824.      Extract the Nth word (one-origin) of TEXT.
  825.      *Note Functions for File Names: File Name Functions.
  826.  
  827. `$(words TEXT)'
  828.      Count the number of words in TEXT.
  829.      *Note Functions for File Names: File Name Functions.
  830.  
  831. `$(firstword NAMES...)'
  832.      Extract the first word of NAMES.
  833.      *Note Functions for File Names: File Name Functions.
  834.  
  835. `$(wildcard PATTERN...)'
  836.      Find file names matching a shell file name pattern (*not* a `%'
  837.      pattern).
  838.      *Note The Function `wildcard': Wildcard Function.
  839.  
  840. `$(shell COMMAND)'
  841.      Execute a shell command and return its output.
  842.      *Note The `shell' Function: Shell Function.
  843.  
  844. `$(origin VARIABLE)'
  845.      Return a string describing how the `make' variable VARIABLE was
  846.      defined.
  847.      *Note The `origin' Function: Origin Function.
  848.  
  849. `$(foreach VAR,WORDS,TEXT)'
  850.      Evaluate TEXT with VAR bound to each word in WORDS, and
  851.      concatenate the results.
  852.      *Note The `foreach' Function: Foreach Function.
  853.  
  854.    Here is a summary of the automatic variables.  *Note Automatic
  855. Variables: Automatic, for full information.
  856.  
  857. `$@'
  858.      The file name of the target.
  859.  
  860. `$%'
  861.      The target member name, when the target is an archive member.
  862.  
  863. `$<'
  864.      The name of the first dependency.
  865.  
  866. `$?'
  867.      The names of all the dependencies that are newer than the target,
  868.      with spaces between them.  For dependencies which are archive
  869.      members, only the member named is used (*note Archives::.).
  870.  
  871. `$^'
  872. `$+'
  873.      The names of all the dependencies, with spaces between them.  For
  874.      dependencies which are archive members, only the member named is
  875.      used (*note Archives::.).  The value of `$^' omits duplicate
  876.      dependencies, while `$+' retains them and preserves their order.
  877.  
  878. `$*'
  879.      The stem with which an implicit rule matches (*note How Patterns
  880.      Match: Pattern Match.).
  881.  
  882. `$(@D)'
  883. `$(@F)'
  884.      The directory part and the file-within-directory part of `$@'.
  885.  
  886. `$(*D)'
  887. `$(*F)'
  888.      The directory part and the file-within-directory part of `$*'.
  889.  
  890. `$(%D)'
  891. `$(%F)'
  892.      The directory part and the file-within-directory part of `$%'.
  893.  
  894. `$(<D)'
  895. `$(<F)'
  896.      The directory part and the file-within-directory part of `$<'.
  897.  
  898. `$(^D)'
  899. `$(^F)'
  900.      The directory part and the file-within-directory part of `$^'.
  901.  
  902. `$(+D)'
  903. `$(+F)'
  904.      The directory part and the file-within-directory part of `$+'.
  905.  
  906. `$(?D)'
  907. `$(?F)'
  908.      The directory part and the file-within-directory part of `$?'.
  909.  
  910.    These variables are used specially by GNU `make':
  911.  
  912. `MAKEFILES'
  913.      Makefiles to be read on every invocation of `make'.
  914.      *Note The Variable `MAKEFILES': MAKEFILES Variable.
  915.  
  916. `VPATH'
  917.      Directory search path for files not found in the current directory.
  918.      *Note `VPATH' Search Path for All Dependencies: General Search.
  919.  
  920. `SHELL'
  921.      The name of the system default command interpreter, usually
  922.      `/bin/sh'.  You can set `SHELL' in the makefile to change the
  923.      shell used to run commands.  *Note Command Execution: Execution.
  924.  
  925. `MAKESHELL'
  926.      On MS-DOS only, the name of the command interpreter that is to be
  927.      used by `make'. This value takes precedence over the value of
  928.      `SHELL'.  *Note MAKESHELL variable: Execution.
  929.  
  930. `MAKE'
  931.      The name with which `make' was invoked.  Using this variable in
  932.      commands has special meaning.  *Note How the `MAKE' Variable
  933.      Works: MAKE Variable.
  934.  
  935. `MAKELEVEL'
  936.      The number of levels of recursion (sub-`make's).
  937.      *Note Variables/Recursion::.
  938.  
  939. `MAKEFLAGS'
  940.      The flags given to `make'.  You can set this in the environment or
  941.      a makefile to set flags.
  942.      *Note Communicating Options to a Sub-`make': Options/Recursion.
  943.  
  944. `MAKECMDGOALS'
  945.      The targets given to `make' on the command line.  Setting this
  946.      variable has no effect on the operation of `make'.
  947.      *Note Arguments to Specify the Goals: Goals.
  948.  
  949. `SUFFIXES'
  950.      The default list of suffixes before `make' reads any makefiles.
  951.  
  953. File: make.info,  Node: Complex Makefile,  Next: Concept Index,  Prev: Quick Reference,  Up: Top
  954.  
  955. Complex Makefile Example
  956. ************************
  957.  
  958.    Here is the makefile for the GNU `tar' program.  This is a
  959. moderately complex makefile.
  960.  
  961.    Because it is the first target, the default goal is `all'.  An
  962. interesting feature of this makefile is that `testpad.h' is a source
  963. file automatically created by the `testpad' program, itself compiled
  964. from `testpad.c'.
  965.  
  966.    If you type `make' or `make all', then `make' creates the `tar'
  967. executable, the `rmt' daemon that provides remote tape access, and the
  968. `tar.info' Info file.
  969.  
  970.    If you type `make install', then `make' not only creates `tar',
  971. `rmt', and `tar.info', but also installs them.
  972.  
  973.    If you type `make clean', then `make' removes the `.o' files, and
  974. the `tar', `rmt', `testpad', `testpad.h', and `core' files.
  975.  
  976.    If you type `make distclean', then `make' not only removes the same
  977. files as does `make clean' but also the `TAGS', `Makefile', and
  978. `config.status' files.  (Although it is not evident, this makefile (and
  979. `config.status') is generated by the user with the `configure' program,
  980. which is provided in the `tar' distribution, but is not shown here.)
  981.  
  982.    If you type `make realclean', then `make' removes the same files as
  983. does `make distclean' and also removes the Info files generated from
  984. `tar.texinfo'.
  985.  
  986.    In addition, there are targets `shar' and `dist' that create
  987. distribution kits.
  988.  
  989.      # Generated automatically from Makefile.in by configure.
  990.      # Un*x Makefile for GNU tar program.
  991.      # Copyright (C) 1991 Free Software Foundation, Inc.
  992.      
  993.      # This program is free software; you can redistribute
  994.      # it and/or modify it under the terms of the GNU
  995.      # General Public License ...
  996.      ...
  997.      ...
  998.      
  999.      SHELL = /bin/sh
  1000.      
  1001.      #### Start of system configuration section. ####
  1002.      
  1003.      srcdir = .
  1004.      
  1005.      # If you use gcc, you should either run the
  1006.      # fixincludes script that comes with it or else use
  1007.      # gcc with the -traditional option.  Otherwise ioctl
  1008.      # calls will be compiled incorrectly on some systems.
  1009.      CC = gcc -O
  1010.      YACC = bison -y
  1011.      INSTALL = /usr/local/bin/install -c
  1012.      INSTALLDATA = /usr/local/bin/install -c -m 644
  1013.      
  1014.      # Things you might add to DEFS:
  1015.      # -DSTDC_HEADERS        If you have ANSI C headers and
  1016.      #                       libraries.
  1017.      # -DPOSIX               If you have POSIX.1 headers and
  1018.      #                       libraries.
  1019.      # -DBSD42               If you have sys/dir.h (unless
  1020.      #                       you use -DPOSIX), sys/file.h,
  1021.      #                       and st_blocks in `struct stat'.
  1022.      # -DUSG                 If you have System V/ANSI C
  1023.      #                       string and memory functions
  1024.      #                       and headers, sys/sysmacros.h,
  1025.      #                       fcntl.h, getcwd, no valloc,
  1026.      #                       and ndir.h (unless
  1027.      #                       you use -DDIRENT).
  1028.      # -DNO_MEMORY_H         If USG or STDC_HEADERS but do not
  1029.      #                       include memory.h.
  1030.      # -DDIRENT              If USG and you have dirent.h
  1031.      #                       instead of ndir.h.
  1032.      # -DSIGTYPE=int         If your signal handlers
  1033.      #                       return int, not void.
  1034.      # -DNO_MTIO             If you lack sys/mtio.h
  1035.      #                       (magtape ioctls).
  1036.      # -DNO_REMOTE           If you do not have a remote shell
  1037.      #                       or rexec.
  1038.      # -DUSE_REXEC           To use rexec for remote tape
  1039.      #                       operations instead of
  1040.      #                       forking rsh or remsh.
  1041.      # -DVPRINTF_MISSING     If you lack vprintf function
  1042.      #                       (but have _doprnt).
  1043.      # -DDOPRNT_MISSING      If you lack _doprnt function.
  1044.      #                       Also need to define
  1045.      #                       -DVPRINTF_MISSING.
  1046.      # -DFTIME_MISSING       If you lack ftime system call.
  1047.      # -DSTRSTR_MISSING      If you lack strstr function.
  1048.      # -DVALLOC_MISSING      If you lack valloc function.
  1049.      # -DMKDIR_MISSING       If you lack mkdir and
  1050.      #                       rmdir system calls.
  1051.      # -DRENAME_MISSING      If you lack rename system call.
  1052.      # -DFTRUNCATE_MISSING   If you lack ftruncate
  1053.      #                       system call.
  1054.      # -DV7                  On Version 7 Unix (not
  1055.      #                       tested in a long time).
  1056.      # -DEMUL_OPEN3          If you lack a 3-argument version
  1057.      #                       of open, and want to emulate it
  1058.      #                       with system calls you do have.
  1059.      # -DNO_OPEN3            If you lack the 3-argument open
  1060.      #                       and want to disable the tar -k
  1061.      #                       option instead of emulating open.
  1062.      # -DXENIX               If you have sys/inode.h
  1063.      #                       and need it 94 to be included.
  1064.      
  1065.      DEFS =  -DSIGTYPE=int -DDIRENT -DSTRSTR_MISSING \
  1066.              -DVPRINTF_MISSING -DBSD42
  1067.      # Set this to rtapelib.o unless you defined NO_REMOTE,
  1068.      # in which case make it empty.
  1069.      RTAPELIB = rtapelib.o
  1070.      LIBS =
  1071.      DEF_AR_FILE = /dev/rmt8
  1072.      DEFBLOCKING = 20
  1073.      
  1074.      CDEBUG = -g
  1075.      CFLAGS = $(CDEBUG) -I. -I$(srcdir) $(DEFS) \
  1076.              -DDEF_AR_FILE=\"$(DEF_AR_FILE)\" \
  1077.              -DDEFBLOCKING=$(DEFBLOCKING)
  1078.      LDFLAGS = -g
  1079.      
  1080.      prefix = /usr/local
  1081.      # Prefix for each installed program,
  1082.      # normally empty or `g'.
  1083.      binprefix =
  1084.      
  1085.      # The directory to install tar in.
  1086.      bindir = $(prefix)/bin
  1087.      
  1088.      # The directory to install the info files in.
  1089.      infodir = $(prefix)/info
  1090.      
  1091.      #### End of system configuration section. ####
  1092.      
  1093.      SRC1 =  tar.c create.c extract.c buffer.c \
  1094.              getoldopt.c update.c gnu.c mangle.c
  1095.      SRC2 =  version.c list.c names.c diffarch.c \
  1096.              port.c wildmat.c getopt.c
  1097.      SRC3 =  getopt1.c regex.c getdate.y
  1098.      SRCS =  $(SRC1) $(SRC2) $(SRC3)
  1099.      OBJ1 =  tar.o create.o extract.o buffer.o \
  1100.              getoldopt.o update.o gnu.o mangle.o
  1101.      OBJ2 =  version.o list.o names.o diffarch.o \
  1102.              port.o wildmat.o getopt.o
  1103.      OBJ3 =  getopt1.o regex.o getdate.o $(RTAPELIB)
  1104.      OBJS =  $(OBJ1) $(OBJ2) $(OBJ3)
  1105.      AUX =   README COPYING ChangeLog Makefile.in  \
  1106.              makefile.pc configure configure.in \
  1107.              tar.texinfo tar.info* texinfo.tex \
  1108.              tar.h port.h open3.h getopt.h regex.h \
  1109.              rmt.h rmt.c rtapelib.c alloca.c \
  1110.              msd_dir.h msd_dir.c tcexparg.c \
  1111.              level-0 level-1 backup-specs testpad.c
  1112.      
  1113.      all:    tar rmt tar.info
  1114.      
  1115.      tar:    $(OBJS)
  1116.              $(CC) $(LDFLAGS) -o $@ $(OBJS) $(LIBS)
  1117.      
  1118.      rmt:    rmt.c
  1119.              $(CC) $(CFLAGS) $(LDFLAGS) -o $@ rmt.c
  1120.      
  1121.      tar.info: tar.texinfo
  1122.              makeinfo tar.texinfo
  1123.      
  1124.      install: all
  1125.              $(INSTALL) tar $(bindir)/$(binprefix)tar
  1126.              -test ! -f rmt || $(INSTALL) rmt /etc/rmt
  1127.              $(INSTALLDATA) $(srcdir)/tar.info* $(infodir)
  1128.      
  1129.      $(OBJS): tar.h port.h testpad.h
  1130.      regex.o buffer.o tar.o: regex.h
  1131.      # getdate.y has 8 shift/reduce conflicts.
  1132.      
  1133.      testpad.h: testpad
  1134.              ./testpad
  1135.      
  1136.      testpad: testpad.o
  1137.              $(CC) -o $@ testpad.o
  1138.      
  1139.      TAGS:   $(SRCS)
  1140.              etags $(SRCS)
  1141.      
  1142.      clean:
  1143.              rm -f *.o tar rmt testpad testpad.h core
  1144.      
  1145.      distclean: clean
  1146.              rm -f TAGS Makefile config.status
  1147.      
  1148.      realclean: distclean
  1149.              rm -f tar.info*
  1150.      
  1151.      shar: $(SRCS) $(AUX)
  1152.              shar $(SRCS) $(AUX) | compress \
  1153.                > tar-`sed -e '/version_string/!d' \
  1154.                           -e 's/[^0-9.]*\([0-9.]*\).*/\1/' \
  1155.                           -e q
  1156.                           version.c`.shar.Z
  1157.      
  1158.      dist: $(SRCS) $(AUX)
  1159.              echo tar-`sed \
  1160.                   -e '/version_string/!d' \
  1161.                   -e 's/[^0-9.]*\([0-9.]*\).*/\1/' \
  1162.                   -e q
  1163.                   version.c` > .fname
  1164.              -rm -rf `cat .fname`
  1165.              mkdir `cat .fname`
  1166.              ln $(SRCS) $(AUX) `cat .fname`
  1167.              -rm -rf `cat .fname` .fname
  1168.              tar chZf `cat .fname`.tar.Z `cat .fname`
  1169.      
  1170.      tar.zoo: $(SRCS) $(AUX)
  1171.              -rm -rf tmp.dir
  1172.              -mkdir tmp.dir
  1173.              -rm tar.zoo
  1174.              for X in $(SRCS) $(AUX) ; do \
  1175.                  echo $$X ; \
  1176.                  sed 's/$$/^M/' $$X \
  1177.                  > tmp.dir/$$X ; done
  1178.              cd tmp.dir ; zoo aM ../tar.zoo *
  1179.              -rm -rf tmp.dir
  1180.  
  1181.